home *** CD-ROM | disk | FTP | other *** search
/ Network Supervisor's Toolkit / Network Supervisor's Toolkit.iso / tools / lu62 / debug / rem_dir.c < prev    next >
C/C++ Source or Header  |  1996-07-10  |  9KB  |  265 lines
  1. /*
  2.  *  CopyRight 1995. Nicholas Poljakov all rights reserved.
  3.  */
  4. /*********************** REM_DIR ****************************/
  5. /*                 input-string pointer                     */
  6. /************************************************************/
  7.  
  8. #include <string.h>
  9. #include <io.h>
  10. #include <fcntl.h>
  11. #include <stdlib.h>
  12. #include <state1.h>
  13. #include <direct.h>
  14. #include <dos.h>
  15. #define MAX_PATH 40
  16. #define MIN 1
  17.  
  18. extern int sw;
  19. extern char lu_id[8];
  20. extern char tp_id[8];
  21. extern char tp_exist;
  22. extern unsigned  long conv_id;
  23. int get_f(void *, int);
  24.  
  25.  
  26.       dir(p)
  27.         char *p;
  28.            {
  29.  
  30.                p += 4;
  31.                if (memcmp(p,"get",3) == 0)
  32.                    return(gd());
  33.                if (memcmp(p,"mkdir",5) == 0)
  34.                    return(md(p+6));
  35.                if (memcmp(p,"path",4) == 0)
  36.                    return(pt());
  37.                if (memcmp(p,"cd",2) == 0)
  38.                    return(rcd(p+3));
  39.             }
  40. /************************************************************************/
  41. /*       gd() - get contents of directory                               */
  42. /************************************************************************/
  43.  
  44.     gd()
  45.             {
  46.  
  47.                struct dt {
  48.                            char reserv[21];
  49.                            char attr;
  50.                            unsigned int time;
  51.                            unsigned int date;
  52.                            unsigned long int size;
  53.                            char name[18];
  54.                          }  *s_dta;
  55.                unsigned char rts;
  56.                unsigned char wr;
  57.                unsigned int max_length ;
  58.                struct rc {
  59.                            unsigned int prim;
  60.                            unsigned long sec;
  61.                           } v_rc;
  62.                struct msg {  /*send_data*/
  63.                             int len;
  64.                             char str[sizeof(struct dt)];
  65.                            } gds;
  66.                unsigned long rc;
  67.                int length;
  68.  
  69.               max_length = 2017;
  70.               recwait (tp_id,
  71.                     conv_id,
  72.                     ll,
  73.                     &v_rc,
  74.                     &length,
  75.                     max_length,
  76.                     &rts,
  77.                     &gds,
  78.                     &wr);
  79.               if (v_rc.prim != 0) {
  80.                     return -1;
  81.               }
  82.  
  83.                sw = 0;
  84.                if ((s_dta = malloc(sizeof(struct dt))) == NULL) {
  85.                     return -1;
  86.                }
  87.                while ((get_f(s_dta, 0)) != -1)
  88.                     {
  89.                        memcpy(gds.str, s_dta,sizeof(struct dt)) ;
  90.                        gds.len =sizeof(struct dt) + 2;
  91.                        length=gds.len;
  92.                        send_data(tp_id,
  93.                                  conv_id,
  94.                                  &gds,
  95.                                  0,
  96.                                  0,
  97.                                  length,
  98.                                  &v_rc,
  99.                                  &rts);
  100.                        max_length = 255;
  101.                        if (v_rc.prim == 0) {
  102.                            recwait (tp_id,
  103.                                     conv_id,
  104.                                     ll,
  105.                                     &v_rc,
  106.                                     &length,
  107.                                     max_length,
  108.                                     &rts,
  109.                                     &gds,
  110.                                     &wr);
  111.                        }
  112.                        else
  113.                             return -1;
  114.                     }  /* while */
  115.  
  116.                   deallocate (tp_id,
  117.                               conv_id,
  118.                               Flush,
  119.                               &v_rc);
  120.                   if (v_rc.prim != 0) {
  121.                               return -1;
  122.                            }
  123.                   tp_ended (tp_id, &rc);
  124.                   return 0;
  125.               }
  126. /*************************************************************************/
  127. /*                md(p) - make a directory                               */
  128. /*************************************************************************/
  129.        md(p)
  130.           char *p;
  131.               {
  132.                unsigned char rts;
  133.                unsigned char wr;
  134.                unsigned int max_length ;
  135.                struct rc {
  136.                            unsigned int prim;
  137.                            unsigned long sec;
  138.                           } v_rc;
  139.                struct msg {  /*send_data*/
  140.                             int len;
  141.                             char str[MIN];
  142.                            } gds;
  143.            unsigned long rc;
  144.            int length;
  145.  
  146.                    mkdir(p);
  147.                    max_length = 255;
  148.                    recwait (tp_id,
  149.                             conv_id,
  150.                             ll,
  151.                             &v_rc,
  152.                             &length,
  153.                             max_length,
  154.                             &rts,
  155.                             &gds,
  156.                             &wr);
  157.                   tp_ended (tp_id, &rc);
  158.                   return 0;
  159.           }
  160. /*****************************************************************************/
  161. /*            pt() - get a current path                                      */
  162. /*****************************************************************************/
  163.       pt()
  164.             {
  165.                unsigned char rts;
  166.                unsigned char wr;
  167.                unsigned int max_length ;
  168.                struct rc {
  169.                            unsigned int prim;
  170.                            unsigned long sec;
  171.                           } v_rc;
  172.                struct msg {  /*send_data*/
  173.                             int len;
  174.                 char str[_MAX_PATH];
  175.                            } gds;
  176.                unsigned long rc;
  177.                int length;
  178.  
  179.                max_length = 2017;
  180.                recwait (tp_id,
  181.                         conv_id,
  182.                         ll,
  183.                         &v_rc,
  184.                         &length,
  185.                         max_length,
  186.                         &rts,
  187.                         &gds,
  188.                         &wr);
  189.                if (v_rc.prim != 0) {
  190.                      return -1;
  191.                }
  192.  
  193.            _getdcwd(0, gds.str, _MAX_PATH);
  194.  
  195.                gds.len = strlen(gds.str) + 2;
  196.                length = gds.len;
  197.  
  198.                send_data(tp_id,
  199.                          conv_id,
  200.                          &gds,
  201.                          0,
  202.                          0,
  203.                          length,
  204.                          &v_rc,
  205.                          &rts);
  206.  
  207.                deallocate (tp_id,
  208.                            conv_id,
  209.                            Flush,
  210.                            &v_rc);
  211.  
  212.                tp_ended (tp_id, &rc);
  213.  
  214.                return 0;
  215.                  }
  216. /*****************************************************************************/
  217. /*            rcd(p) - make a cd command                                     */
  218. /*****************************************************************************/
  219.      rcd(p)
  220.         char *p;
  221.             {
  222.                unsigned char rts;
  223.                unsigned char wr;
  224.                unsigned int max_length ;
  225.                struct rc {
  226.                            unsigned int prim;
  227.                            unsigned long sec;
  228.                           } v_rc;
  229.                struct msg {  /*send_data*/
  230.                             int len;
  231.                             char str[MIN];
  232.                            } gds;
  233.                unsigned long rc;
  234.                unsigned char strp[MAX_PATH*2];
  235.            int i;
  236.            int length;
  237.            struct SREGS segregs;
  238.            union REGS regs;
  239.  
  240.             regs.h.ah = 0x3b;
  241.             regs.x.dx = FP_OFF( p );
  242.             segregs.ds = FP_SEG( p );
  243.             intdosx( ®s, ®s, &segregs );
  244.             max_length = 255;
  245.                     recwait (tp_id,
  246.                             conv_id,
  247.                             ll,
  248.                             &v_rc,
  249.                             &length,
  250.                             max_length,
  251.                             &rts,
  252.                             &gds,
  253.                             &wr);
  254.                   deallocate (tp_id,
  255.                               conv_id,
  256.                               Flush,
  257.                               &v_rc);
  258.                   if (v_rc.prim != 0) {
  259.                               return -1;
  260.                   }
  261.                     tp_ended (tp_id, &rc);
  262.                     return 0;
  263.           }
  264. /***************************** THE END *************************************/
  265.